#include <iostream>

using namespace std;

struct S1
{
	char c1; // 1;
	int i;   // +3 + 4;
	char c2; //1;  9;
	// 4*3 = 12;
};

int main()
{
	printf("%d\n", sizeof(struct S1));
	return 0;
}

struct S2
{
	char c1;//1
	char c2;//1
	int i;//2+4;
	//8
};


int main()
{
	printf("%d\n", sizeof(struct S2));
	return 0;
}


struct S3
{
	double d;//8
	char c;//1
	int i;//3+4
	//16
};

struct S4
{
	char c1;//1
	struct S3 s3;//16
	double d;//24 + 8;
	//32;
};


int main()
{
	printf("%d\n", sizeof(struct S4));
	
}


//#pragma pack(8)//设置默认对齐数为8
struct S1
{
	char c1;//1
	int i;//
	char c2;
};

#pragma pack()//取消设置的默认对齐数，还原为默认
#pragma pack(1)//设置默认对齐数为1
struct S2
{
	char c1;//1
	int i;//4
	char c2;//1
	//6
};
#pragma pack()//取消设置的默认对齐数，还原为默认
int main()
{
	//输出的结果是什么？
	printf("%d\n", sizeof(struct S1));
	printf("%d\n", sizeof(struct S2));

	return 0;
}

struct A
{
	int _a : 2;//1
	int _b : 5;//1
	int _c : 10;//4
	int _d : 30;//4
};

union Un
{
	char c;
	int i;
};


int main()
{
	//printf("%d\n", sizeof(struct A));
	union Un un;
	printf("%d\n", sizeof(un));
	return 0;
}


union Un
{
	int i;
	char c;
};
union Un un;

int main()
{
	printf("%d\n", &(un.i));
	printf("%d\n", &(un.c));

	un.i = 0x11223344;
	un.c = 0x55;
	printf("%x\n", un.i);
	printf("%d\n", &(un.c));
	return 0;
}


union Un1
{
	char c[5];//5
	int i;
	//4 * 2 = 8 > 5
};
union Un2
{
	short c[7];//14
	int i;
	//4 * 4 = 16 > 14
};


int main()
{
	printf("%d\n", sizeof(union Un1));
	printf("%d\n", sizeof(union Un2));

	return 0;
}


#include <stdio.h>
int main()
{
	//代码1
	int num = 0;
	scanf("%d", &num);
	//int arr[num] = { 0 };
	//代码2
	int* ptr = NULL;
	ptr = (int*)malloc(num * sizeof(int));
	if (NULL != ptr)//判断ptr指针是否为空
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = 0;
		}
	}
	free(ptr);//释放ptr所指向的动态内存
	ptr = NULL;//是否有必要？
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (NULL != p)
	{
		//使用空间

	}
		free(p);
		p = NULL;
		return 0;
}


// #include <stdio.h>
// int main()
// {
// 	int* ptr = (int*)malloc(100);
// 	if (ptr != NULL)
// 	{
// 		//业务处理
// 	}
// 	else
// 	{
// 		exit(EXIT_FAILURE);
// 	}
// 	//扩展容量
// 	//代码1
// 	ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)

// 	//代码2
// 	int* p = NULL;
// 	p = realloc(ptr, 1000);
// 	if (p != NULL)
// 	{
// 		ptr = p;
// 	}
// 	//业务处理
// 	free(ptr);
// 	return 0;
// }


// void test()
// {
// 	int* p = (int*)malloc(INT_MAX / 4);
// 	//if (p == nullptr) return nullptr; 需要置空判断.
// 	*p = 20;//如果p的值是NULL，就会有问题
// 	free(p);
// }


void test()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (NULL == p)
	{
		exit(EXIT_FAILURE);
	}
	//越界访问了.
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;//当i是10的时候越界访问
	}
	free(p);
}

void test()
{
	int a = 10;
	int* p = &a;
	//非动态开辟进行释放.
	free(p);//ok?
}

void test()
{
	int* p = (int*)malloc(100);
	p++;
	//只是释放了一部分.还没有判空.
	free(p);//p不再指向动态内存的起始位置
	//p = nullptr;
}


//#include <stdio.h>
//int main()
//{
//	FILE* pFile;
//	//打开文件
//	pFile = fopen("myfile.txt", "w");
//	//文件操作
//	if (pFile != NULL)
//	{
//		fputs("fopen example", pFile);
//		//关闭文件
//		fclose(pFile);
//	}
//	return 0;
//}

#include <stdio.h>
int main()
{
	FILE* pFile;
	pFile = fopen("example.txt", "wb");
	fputs("This is an apple.", pFile);
	fseek(pFile, 9, SEEK_SET);
	fputs("sam", pFile);
	fclose(pFile);
	return 0;
}